#include "../include/double_Link_list.h"

// 双向链表的创建
Double_Link_List *init_double_link_list()
{
    // 创建头节点的动态空间
    Double_Link_List *list = (Double_Link_List *)malloc(sizeof(Double_Link_List));
    if (NULL == list)
    {
        ERRLOG("动态空间创建失败");
        return NULL;
    }
    list->next = NULL;

    return list;
}

// 双向链表的插入
void insert_double_node(Double_Link_List *list, Log_in_data data, int pos)
{
    // 安全判断
    if (NULL == list)
    {
        ERRLOG("链表为NULL!");
        return;
    }
    // 1、 创建新空间
    Double_Node *new_node = (Double_Node *)malloc(sizeof(Double_Node));
    // 安全判断
    if (NULL == new_node)
    {
        ERRLOG("动态空间创建失败");
        return;
    }
    // 初始化
    new_node->data = data;
    new_node->next = NULL;
    new_node->prev = NULL;

    // 2 头插
    if (1 == pos)
    {
        // 1 将 new_node 的 next 指向 头结点 的next
        new_node->next = list->next;
        // 2 将 头结点的 next 结点 的 prev 指向 new_node
        // 需要进行if判断 如果 list->next = NULL 则不需要这一步
        if (NULL != list->next)
        {
            list->next->prev = new_node;
        }

        // 3 将 list->next 指向 new_node
        list->next = new_node;
        return;
    }
    // 任意位置插入
    //  先找到插入前一个位置
    Double_Node *p = list->next; // 用于遍历链表
    int num = 1;                 // 记录结点的位置
    while (p != NULL && pos - 1 != num)
    {
        p = p->next;
        num++;
    }
    // 安全判断
    if (NULL == p)
    {
        ERRLOG("插入的位置非法");
        free(new_node); // 释放新结点的空间
        return;
    }
    // 开始插入
    //  1、 将 new_node 的 next 指向 p 的next
    new_node->next = p->next;
    //  2、 将 p 的 next 的 prev 指向 new_node
    //  如果插入的是最后一个位置则不需要此步
    if (NULL != p->next)
    {
        p->next->prev = new_node;
    }
    //  3、 将 new_node 的 prev 指向 p
    new_node->prev = p;
    //  4、 将 p 的next 指向 new_node
    p->next = new_node;
    return;
}

// 双向链表的删除
Log_in_data delete_double_node(Double_Link_List *list, int pos)
{
    Log_in_data del_data;                   // 返回删除信息
    memset(&del_data, 0, sizeof(del_data)); // 数据清0
    // 安全判断
    if (NULL == list)
    {
        ERRLOG("链表为NULL!");
        return del_data;
    }
    if (NULL == list->next)
    {
        ERRLOG("链表为空!");
        return del_data;
    }

    // 1、 创建遍历、释放的结点
    Double_Node *p1 = list->next; // 用于找到删除结点前一个位置的结点
    Double_Node *p2 = p1->next;   // 用于释放删除结点
    // 2 头删
    if (1 == pos)
    {
        // 1 将 将头节点 的 next 指向 p1
        list->next = p1->next;
        // 2 将 p1的 next 结点 指向空
        p1->next->prev = NULL;
        // 保存删除的信息
        del_data = p1->data;
        // 3 释放结点P1
        free(p1);
        return del_data;
    }
    // 任意位置删除
    // 先遍历找到删除前一个位置
    for (int i = 1; i < pos - 1 && NULL != p1->next; i++)
    {
        p1 = p1->next;
        p2 = p2->next;
    }
    // 安全判断
    if (NULL == p1->next)
    {
        ERRLOG("删除的位置非法");
        return del_data;
    }
    // 开始删除
    // 1 将 p1 的 next 指向 p2的next
    p1->next = p2->next;
    // 2 将 p2的 next 的prev指向p1
    // 需要进行if判断 如果 p2->next = NULL 则不需要这一步 尾删
    if (NULL != p2->next)
    {
        p2->next->prev = p1;
    }
    // 保存删除的信息
    del_data = p2->data;
    // 3 释放结点P2
    free(p2);
    return del_data;
}

// 双向链表的遍历
void print_forward_double_link_list(Double_Link_List *list)
{
    // 安全判断
    if (NULL == list)
    {
        ERRLOG("链表的动态空间为空");
        return;
    }

    Double_Node *ptr = list->next;

    for (size_t i = 0; NULL != ptr; i++)
    {
        printf("账号:%s\t密码:%s\tid:%c\n", ptr->data.name, ptr->data.password, ptr->data.id);
        ptr = ptr->next;
    }

    return;
}
void print_backwards_double_link_list(Double_Link_List *list);

// 双向链表的查找
Double_Node *find_double_node_pos(Double_Link_List *list, int pos);
//按值查找
Double_Node *find_double_node_name(Double_Link_List *list, char *name)
{
    print_forward_double_link_list(list);
    // 安全判断
    if (NULL == list)
    {
        ERRLOG("链表为NULL!");
        return NULL;
    }
    if (NULL == list->next)
    {
        ERRLOG("链表为空!");
        return NULL;
    }
    Double_Node *P=list->next;      //用于遍历
    //遍历比较
    while (NULL!=P)
    {
        if (!strcmp(P->data.name,name))
        {
            return P;
        }
        P = P->next;
    }
    if (NULL==P)
    {
        ERRLOG("查无此人!");
        return NULL;
    }
   
   
   
}
// 按值查找返回位置
int find_pos(Double_Link_List *list, char *name)
{
    int pos = 1;//位置标识
    // 安全判断
    if (NULL == list)
    {
        ERRLOG("链表为NULL!");
        return 0;
    }
    if (NULL == list->next)
    {
        ERRLOG("链表为空!");
        return 0;
    }
    Double_Node *P = list->next; // 用于遍历
    // 遍历比较
    while (NULL != P)
    {
        if (!strcmp(P->data.name, name))
        {
            return pos;
        }
        P = P->next;
        pos++;
    }
    if (NULL == P)
    {
        ERRLOG("查无此人!");
        return 0;
    }
}
// 双向链表的销毁
void free_double_link_list(Double_Link_List **list)
{
    if (NULL == *list)
    {
        ERRLOG("链表的动态空间为空");
        return;
    }
    // 无数据的清空
    if (NULL == (*list)->next)
    {
        ERRLOG("链表内无数据");
        free(*list);
        *list = NULL;
        return;
    }

    // 有数据的清空
    Double_Node *ptr_1 = (*list)->next;
    Double_Node *ptr_2 = ptr_1->next;

    for (size_t i = 0; NULL != ptr_1; i++)
    {
        free(ptr_1);
        ptr_1 = ptr_2;
        if (NULL != ptr_2)
        {
            ptr_2 = ptr_2->next;
        }
    }

    free(*list);
    *list = NULL;

    return;
}
